การเพิ่มประสิทธิภาพ Query ใน Django ORM: select_related vs. prefetch_related

เมื่อแอปพลิเคชัน Django ของคุณเติบโตขึ้น การสืบค้นฐานข้อมูล (query) ที่มีประสิทธิภาพจะกลายเป็นสิ่งสำคัญอย่างยิ่งในการรักษาประสิทธิภาพการทำงานที่ดีที่สุด Django ORM มีเครื่องมืออันทรงพลังเพื่อลดจำนวนการเข้าถึงฐานข้อมูลและปรับปรุงความเร็วของ query สองเทคนิคหลักเพื่อให้บรรลุเป้าหมายนี้คือ select_related และ prefetch_related คู่มือฉบับสมบูรณ์นี้จะอธิบายแนวคิดเหล่านี้ สาธิตการใช้งานด้วยตัวอย่างที่ใช้ได้จริง และช่วยให้คุณเลือกเครื่องมือที่เหมาะสมกับความต้องการเฉพาะของคุณได้

ทำความเข้าใจกับปัญหา N+1

ก่อนที่จะลงลึกในเรื่อง select_related และ prefetch_related สิ่งสำคัญคือต้องเข้าใจปัญหาที่เครื่องมือทั้งสองนี้เข้ามาแก้ไข นั่นคือ: ปัญหา query แบบ N+1 ซึ่งเกิดขึ้นเมื่อแอปพลิเคชันของคุณรัน query เริ่มต้นหนึ่งครั้งเพื่อดึงชุดข้อมูล (object) จากนั้นทำการ query เพิ่มเติม (N queries โดยที่ N คือจำนวน object) เพื่อดึงข้อมูลที่เกี่ยวข้องสำหรับแต่ละ object

ลองพิจารณาตัวอย่างง่ายๆ ที่มีโมเดลแทนนักเขียนและหนังสือ:

            class Author(models.Model):
    name = models.CharField(max_length=255)

class Book(models.Model):
    title = models.CharField(max_length=255)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)

            

              
                Copy
              
            
          

ทีนี้ ลองจินตนาการว่าคุณต้องการแสดงรายชื่อหนังสือพร้อมกับชื่อผู้เขียน วิธีการที่อาจดูเรียบง่ายอาจมีลักษณะดังนี้:

            books = Book.objects.all()
for book in books:
    print(f"{book.title} by {book.author.name}")

            

              
                Copy
              
            
          

โค้ดนี้จะสร้างหนึ่ง query เพื่อดึงหนังสือทั้งหมด จากนั้นจะสร้าง query เพิ่มอีกหนึ่ง query สำหรับหนังสือแต่ละเล่ม เพื่อดึงข้อมูลผู้เขียน หากคุณมีหนังสือ 100 เล่ม คุณจะรัน query ทั้งหมด 101 ครั้ง ซึ่งส่งผลให้เกิดภาระต่อประสิทธิภาพอย่างมาก นี่คือปัญหา N+1

แนะนำ select_related

select_related ใช้สำหรับการเพิ่มประสิทธิภาพ query ที่เกี่ยวข้องกับความสัมพันธ์แบบ one-to-one และ foreign key โดยจะทำงานโดยการ join ตารางที่เกี่ยวข้องใน query เริ่มต้น ซึ่งทำให้สามารถดึงข้อมูลที่เกี่ยวข้องได้ในการเข้าถึงฐานข้อมูลเพียงครั้งเดียว

ลองกลับไปดูตัวอย่างนักเขียนและหนังสือของเรา เพื่อแก้ไขปัญหา N+1 เราสามารถใช้ select_related ได้ดังนี้:

            books = Book.objects.all().select_related('author')
for book in books:
    print(f"{book.title} by {book.author.name}")

            

              
                Copy
              
            
          

ตอนนี้ Django จะรัน query ที่ซับซ้อนขึ้นเพียง query เดียว ซึ่งจะทำการ join ตาราง Book และ Author เมื่อคุณเข้าถึง book.author.name ในลูป ข้อมูลนั้นพร้อมใช้งานอยู่แล้ว และจะไม่มีการ query ฐานข้อมูลเพิ่มเติมอีก

การใช้ select_related กับความสัมพันธ์หลายระดับ

select_related สามารถสืบค้นข้ามความสัมพันธ์ได้หลายระดับ ตัวอย่างเช่น หากคุณมีโมเดลที่มี foreign key ไปยังโมเดลอื่น ซึ่งในทางกลับกันก็มี foreign key ไปยังอีกโมเดลหนึ่ง คุณสามารถใช้ select_related เพื่อดึงข้อมูลที่เกี่ยวข้องทั้งหมดได้ในครั้งเดียว

            class Country(models.Model):
    name = models.CharField(max_length=255)

class AuthorProfile(models.Model):
    author = models.OneToOneField(Author, on_delete=models.CASCADE)
    country = models.ForeignKey(Country, on_delete=models.CASCADE)

# Add country to Author
Author.profile = models.OneToOneField(AuthorProfile, on_delete=models.CASCADE, null=True, blank=True)

authors = Author.objects.all().select_related('profile__country')
for author in authors:
    print(f"{author.name} is from {author.profile.country.name if author.profile else 'Unknown'}")

            

              
                Copy
              
            
          

ในกรณีนี้ select_related('profile__country') จะดึงข้อมูล AuthorProfile และ Country ที่เกี่ยวข้องมาใน query เดียว โปรดสังเกตเครื่องหมายขีดล่างสองตัว (__) ซึ่งช่วยให้คุณสามารถสำรวจโครงสร้างความสัมพันธ์ได้

ข้อจำกัดของ select_related

select_related มีประสิทธิภาพสูงสุดกับความสัมพันธ์แบบ one-to-one และ foreign key ไม่เหมาะสำหรับความสัมพันธ์แบบ many-to-many หรือ reverse foreign key เนื่องจากอาจนำไปสู่ query ที่ใหญ่และไม่มีประสิทธิภาพเมื่อต้องจัดการกับชุดข้อมูลที่เกี่ยวข้องจำนวนมาก สำหรับสถานการณ์เหล่านี้ prefetch_related เป็นตัวเลือกที่ดีกว่า

แนะนำ prefetch_related

prefetch_related ถูกออกแบบมาเพื่อเพิ่มประสิทธิภาพ query ที่เกี่ยวข้องกับความสัมพันธ์แบบ many-to-many และ reverse foreign key แทนที่จะใช้การ join, prefetch_related จะทำการ query แยกต่างหากสำหรับแต่ละความสัมพันธ์ แล้วใช้ Python ในการ "join" ผลลัพธ์เข้าด้วยกัน แม้ว่าวิธีนี้จะเกี่ยวข้องกับหลาย query แต่มันอาจมีประสิทธิภาพมากกว่าการใช้ join เมื่อต้องจัดการกับชุดข้อมูลที่เกี่ยวข้องขนาดใหญ่

ลองพิจารณาสถานการณ์ที่หนังสือแต่ละเล่มสามารถมีได้หลายประเภท:

            class Genre(models.Model):
    name = models.CharField(max_length=255)

class Book(models.Model):
    title = models.CharField(max_length=255)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
    genres = models.ManyToManyField(Genre)

            

              
                Copy
              
            
          

ในการดึงรายชื่อหนังสือพร้อมกับประเภทของมัน การใช้ select_related จะไม่เหมาะสม แต่เราจะใช้ prefetch_related แทน:

            books = Book.objects.all().prefetch_related('genres')
for book in books:
    genre_names = [genre.name for genre in book.genres.all()]
    print(f"{book.title} ({', '.join(genre_names)}) by {book.author.name}")

            

              
                Copy
              
            
          

ในกรณีนี้ Django จะรันสอง query: หนึ่ง query เพื่อดึงหนังสือทั้งหมด และอีกหนึ่ง query เพื่อดึงประเภททั้งหมดที่เกี่ยวข้องกับหนังสือเหล่านั้น จากนั้นจะใช้ Python ในการเชื่อมโยงประเภทต่างๆ กับหนังสือที่เกี่ยวข้องอย่างมีประสิทธิภาพ

prefetch_related กับ Reverse Foreign Keys

prefetch_related ยังมีประโยชน์สำหรับการเพิ่มประสิทธิภาพความสัมพันธ์แบบ reverse foreign key ลองพิจารณาตัวอย่างต่อไปนี้:

            class Author(models.Model):
    name = models.CharField(max_length=255)
    country = models.CharField(max_length=255, blank=True, null=True) # Added for clarity

    def __str__(self):
        return self.name

class Book(models.Model):
    title = models.CharField(max_length=255)
    author = models.ForeignKey(Author, related_name='books', on_delete=models.CASCADE)

            

              
                Copy
              
            
          

ในการดึงรายชื่อผู้เขียนและหนังสือของพวกเขา:

            authors = Author.objects.all().prefetch_related('books')
for author in authors:
    book_titles = [book.title for book in author.books.all()]
    print(f"{author.name} has written: {', '.join(book_titles)}")

            

              
                Copy
              
            
          

ในที่นี้ prefetch_related('books') จะดึงหนังสือทั้งหมดที่เกี่ยวข้องกับผู้เขียนแต่ละคนใน query แยกต่างหาก ซึ่งช่วยหลีกเลี่ยงปัญหา N+1 เมื่อเข้าถึง author.books.all()

การใช้ prefetch_related กับ queryset

คุณสามารถปรับแต่งการทำงานของ prefetch_related เพิ่มเติมได้โดยการส่ง queryset ที่กำหนดเองเพื่อดึงอ็อบเจกต์ที่เกี่ยวข้อง ซึ่งมีประโยชน์อย่างยิ่งเมื่อคุณต้องการกรองหรือเรียงลำดับข้อมูลที่เกี่ยวข้อง

            from django.db.models import Prefetch

authors = Author.objects.prefetch_related(Prefetch('books', queryset=Book.objects.filter(title__icontains='django')))

for author in authors:
    django_books = author.books.all()
    print(f"{author.name} has written {len(django_books)} books about Django.")

            

              
                Copy
              
            
          

ในตัวอย่างนี้ อ็อบเจกต์ Prefetch ช่วยให้เราระบุ queryset ที่กำหนดเองซึ่งจะดึงเฉพาะหนังสือที่มีชื่อเรื่องมีคำว่า "django" อยู่

การเชื่อมต่อ (Chaining) prefetch_related

เช่นเดียวกับ select_related คุณสามารถเชื่อมต่อการเรียก prefetch_related เพื่อเพิ่มประสิทธิภาพให้กับความสัมพันธ์หลายๆ อย่าง:

            authors = Author.objects.all().prefetch_related('books__genres')

for author in authors:
  for book in author.books.all():
    genres = book.genres.all()
    print(f"{author.name} wrote {book.title} which is of genre(s) {[genre.name for genre in genres]}")

            

              
                Copy
              
            
          

ตัวอย่างนี้จะทำการ prefetch หนังสือที่เกี่ยวข้องกับผู้เขียน จากนั้นจึง prefetch ประเภทที่เกี่ยวข้องกับหนังสือเหล่านั้น การใช้ prefetch_related แบบเชื่อมต่อช่วยให้คุณสามารถเพิ่มประสิทธิภาพความสัมพันธ์ที่ซ้อนกันลึกๆ ได้

select_related vs. prefetch_related: การเลือกเครื่องมือที่เหมาะสม

แล้วเมื่อไหร่ที่เราควรใช้ select_related และเมื่อไหร่ควรใช้ prefetch_related? นี่คือแนวทางง่ายๆ:

• select_related: ใช้สำหรับความสัมพันธ์แบบ one-to-one และ foreign key ที่คุณต้องการเข้าถึงข้อมูลที่เกี่ยวข้องบ่อยครั้ง มันทำการ join ในฐานข้อมูล ดังนั้นโดยทั่วไปจะเร็วกว่าสำหรับการดึงข้อมูลที่เกี่ยวข้องจำนวนน้อย
• prefetch_related: ใช้สำหรับความสัมพันธ์แบบ many-to-many และ reverse foreign key หรือเมื่อต้องจัดการกับชุดข้อมูลที่เกี่ยวข้องขนาดใหญ่ มันทำการ query แยกต่างหากและใช้ Python ในการ join ผลลัพธ์ ซึ่งอาจมีประสิทธิภาพมากกว่าการ join ขนาดใหญ่ และยังใช้เมื่อคุณต้องการใช้การกรอง queryset แบบกำหนดเองบนอ็อบเจกต์ที่เกี่ยวข้อง

โดยสรุป:

• ประเภทความสัมพันธ์: select_related (ForeignKey, OneToOne), prefetch_related (ManyToManyField, reverse ForeignKey)
• ประเภทของ Query: select_related (JOIN), prefetch_related (Separate Queries + Python Join)
• ขนาดข้อมูล: select_related (ข้อมูลที่เกี่ยวข้องมีขนาดเล็ก), prefetch_related (ข้อมูลที่เกี่ยวข้องมีขนาดใหญ่)

ตัวอย่างการใช้งานจริงและแนวทางปฏิบัติที่ดีที่สุด

นี่คือตัวอย่างการใช้งานจริงและแนวทางปฏิบัติที่ดีที่สุดสำหรับการใช้ select_related และ prefetch_related ในสถานการณ์จริง:

• อีคอมเมิร์ซ: เมื่อแสดงรายละเอียดสินค้า ใช้ select_related เพื่อดึงหมวดหมู่และผู้ผลิตของสินค้า ใช้ prefetch_related เพื่อดึงรูปภาพสินค้าหรือสินค้าที่เกี่ยวข้อง
• โซเชียลมีเดีย: เมื่อแสดงโปรไฟล์ของผู้ใช้ ใช้ prefetch_related เพื่อดึงโพสต์และผู้ติดตามของผู้ใช้ ใช้ select_related เพื่อดึงข้อมูลโปรไฟล์ของผู้ใช้
• ระบบจัดการเนื้อหา (CMS): เมื่อแสดงบทความ ใช้ select_related เพื่อดึงผู้เขียนและหมวดหมู่ ใช้ prefetch_related เพื่อดึงแท็กและความคิดเห็นของบทความ

แนวทางปฏิบัติที่ดีที่สุดโดยทั่วไป:

• ตรวจสอบ Query ของคุณ: ใช้ Django Debug Toolbar หรือเครื่องมือ profiling อื่นๆ เพื่อระบุ query ที่ทำงานช้าและปัญหา N+1 ที่อาจเกิดขึ้น
• เริ่มจากง่ายๆ: เริ่มต้นด้วยการเขียนโค้ดแบบพื้นฐาน แล้วจึงปรับปรุงประสิทธิภาพตามผลลัพธ์จากการ profiling
• ทดสอบอย่างละเอียด: ตรวจสอบให้แน่ใจว่าการปรับปรุงประสิทธิภาพของคุณไม่ก่อให้เกิดบั๊กใหม่หรือทำให้ประสิทธิภาพลดลง
• พิจารณาการใช้ Caching: สำหรับข้อมูลที่มีการเข้าถึงบ่อยครั้ง ควรพิจารณาใช้กลไกการแคช (เช่น cache framework ของ Django หรือ Redis) เพื่อเพิ่มประสิทธิภาพให้ดียิ่งขึ้น
• ใช้ index ในฐานข้อมูล: นี่เป็นสิ่งจำเป็นสำหรับประสิทธิภาพของ query ที่ดีที่สุด โดยเฉพาะอย่างยิ่งใน production

เทคนิคการเพิ่มประสิทธิภาพขั้นสูง

นอกเหนือจาก select_related และ prefetch_related แล้ว ยังมีเทคนิคขั้นสูงอื่นๆ ที่คุณสามารถใช้เพื่อเพิ่มประสิทธิภาพให้กับ query ของ Django ORM ได้:

• only() และ defer(): เมธอดเหล่านี้ช่วยให้คุณสามารถระบุฟิลด์ที่จะดึงจากฐานข้อมูลได้ ใช้ only() เพื่อดึงเฉพาะฟิลด์ที่จำเป็น และ defer() เพื่อยกเว้นฟิลด์ที่ไม่ต้องการใช้ในทันที
• values() และ values_list(): เมธอดเหล่านี้ช่วยให้คุณดึงข้อมูลในรูปแบบ dictionary หรือ tuple แทนที่จะเป็น model instance ของ Django ซึ่งจะมีประสิทธิภาพมากกว่าเมื่อคุณต้องการเพียงบางส่วนของฟิลด์ในโมเดล
• Raw SQL Queries: ในบางกรณี Django ORM อาจไม่ใช่วิธีที่มีประสิทธิภาพที่สุดในการดึงข้อมูล คุณสามารถใช้ raw SQL query สำหรับ query ที่ซับซ้อนหรือต้องการการปรับปรุงประสิทธิภาพอย่างสูง
• การเพิ่มประสิทธิภาพเฉพาะฐานข้อมูล: ฐานข้อมูลที่แตกต่างกัน (เช่น PostgreSQL, MySQL) มีเทคนิคการเพิ่มประสิทธิภาพที่แตกต่างกัน ควรศึกษาและใช้ประโยชน์จากคุณสมบัติเฉพาะของฐานข้อมูลเพื่อเพิ่มประสิทธิภาพให้ดียิ่งขึ้น

ข้อควรพิจารณาด้าน Internationalization

เมื่อพัฒนาแอปพลิเคชัน Django สำหรับผู้ใช้ทั่วโลก สิ่งสำคัญคือต้องพิจารณาเรื่อง internationalization (i18n) และ localization (l10n) ซึ่งอาจส่งผลต่อ query ฐานข้อมูลของคุณได้หลายวิธี:

• ข้อมูลเฉพาะภาษา: คุณอาจต้องจัดเก็บคำแปลของเนื้อหาในฐานข้อมูลของคุณ ใช้ i18n framework ของ Django เพื่อจัดการคำแปลและตรวจสอบให้แน่ใจว่า query ของคุณดึงข้อมูลในเวอร์ชันภาษาที่ถูกต้อง
• ชุดอักขระและ Collation: เลือกชุดอักขระและ collation ที่เหมาะสมสำหรับฐานข้อมูลของคุณเพื่อรองรับภาษาและอักขระที่หลากหลาย
• โซนเวลา: เมื่อจัดการกับวันที่และเวลา ควรคำนึงถึงโซนเวลา จัดเก็บวันที่และเวลาเป็น UTC และแปลงเป็นโซนเวลาท้องถิ่นของผู้ใช้เมื่อแสดงผล
• การจัดรูปแบบสกุลเงิน: เมื่อแสดงราคา ให้ใช้สัญลักษณ์สกุลเงินและการจัดรูปแบบที่เหมาะสมตาม locale ของผู้ใช้

สรุป

การเพิ่มประสิทธิภาพ query ของ Django ORM เป็นสิ่งจำเป็นสำหรับการสร้างเว็บแอปพลิเคชันที่สามารถขยายขนาดและมีประสิทธิภาพสูง ด้วยการทำความเข้าใจและการใช้ select_related และ prefetch_related อย่างมีประสิทธิภาพ คุณสามารถลดจำนวน query ฐานข้อมูลได้อย่างมากและปรับปรุงการตอบสนองโดยรวมของแอปพลิเคชันของคุณ อย่าลืมตรวจสอบ query ของคุณ ทดสอบการเพิ่มประสิทธิภาพอย่างละเอียด และพิจารณาเทคนิคขั้นสูงอื่นๆ เพื่อเพิ่มประสิทธิภาพให้ดียิ่งขึ้น ด้วยการปฏิบัติตามแนวทางปฏิบัติที่ดีที่สุดเหล่านี้ คุณสามารถมั่นใจได้ว่าแอปพลิเคชัน Django ของคุณจะมอบประสบการณ์ผู้ใช้ที่ราบรื่นและมีประสิทธิภาพ ไม่ว่าจะมีขนาดหรือความซับซ้อนเพียงใด และอย่าลืมว่าการออกแบบฐานข้อมูลที่ดีและการกำหนดค่า index อย่างเหมาะสมเป็นสิ่งจำเป็นอย่างยิ่งสำหรับประสิทธิภาพสูงสุด